/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.osiris.persistence.controllers.impl;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityNotFoundException;
import javax.persistence.Query;

import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.Session;
import org.hibernate.criterion.CriteriaSpecification;
import org.hibernate.criterion.Restrictions;
import org.osiris.persistence.Complejidadrequisito;
import org.osiris.persistence.Detallerequisito;
import org.osiris.persistence.Estadorequisito;
import org.osiris.persistence.Impactocambio;
import org.osiris.persistence.Modificaciondeec;
import org.osiris.persistence.Recursosderequisito;
import org.osiris.persistence.Relacionrequisito;
import org.osiris.persistence.RelacionrequisitoPK;
import org.osiris.persistence.Requisito;
import org.osiris.persistence.Requisitosdeproyecto;
import org.osiris.persistence.Riesgo;
import org.osiris.persistence.Subcategoria;
import org.osiris.persistence.Tiporequisito;
import org.osiris.persistence.Usuario;
import org.osiris.persistence.controllers.RequisitoInterface;
import org.osiris.persistence.controllers.exceptions.IllegalOrphanException;
import org.osiris.persistence.controllers.exceptions.NonexistentEntityException;
import org.osiris.server.utils.AppContext;
import org.springframework.context.ApplicationContext;

/**
 *
 * @author amartinez
 */
public class RequisitoJpaController implements RequisitoInterface {

	
	@Resource
	RelacionrequisitoJpaController RelacionrequisitoJpaController;
	Logger logger=Logger.getLogger(this.getClass());
	public RequisitoJpaController() {
        emf = CreadorPU.getEntityManagerFactory();
    }
	private ApplicationContext ctx = AppContext.getApplicationContext();
    private EntityManagerFactory emf = null;

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.AsignacionesInterface#getEntityManager()
	 */
    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    /* (non-Javadoc)
	 * @see org.osiris.persistence.controllers.RequisitoInterface#buscarRequisitos(java.lang.String, java.lang.String, java.lang.String, java.util.Date, java.util.Date, java.lang.Long, java.lang.Long, java.lang.Long, java.lang.Long, java.lang.Long, java.lang.String, java.lang.Integer, java.lang.String, java.lang.String, java.lang.String)
	 */
    @SuppressWarnings("unchecked")
	public List<Requisito> buscarRequisitos(String autor,
			String descripcion, 
			String detallerequisito, 
			Date fechaalta,
			Date fechabaja,
			Long idComplejidadRequisito,
			Long idEstadoRequisito, 
			Long idRequisito,
			Long idSubcategoria,
			Long idTipoRequisito, 
			String nombre,
			Integer PuntosFuncion, 
			String referencia, 
			String responsable,
			String origen,Long proyecto,Long requisito_relacionado,
			boolean dependencia){
    	org.hibernate.Session session = (Session)getEntityManager().getDelegate(); 
    	session.beginTransaction();
    	Criteria criteria = session.createCriteria(Requisito.class);
    	Criteria criteriaRequisitosdeproyecto = session.createCriteria(Requisitosdeproyecto.class);
    	Criteria criteriaDet = null;
    	
    	criteria.add(Restrictions.isNull("fechabaja"));
    	
    	
    	boolean algo=false;
    	
    	if(descripcion!=null){
    		criteria.add(Restrictions.like("descripcion", "%"+descripcion+"%"));
    		logger.info("Busco por descripcion");
    		algo=true;
		}		
		if(fechaalta!=null){
			criteria.add(Restrictions.ge("fechaalta", fechaalta));
			logger.info("Busco por fechaalta");
			algo=true;
		}		
		if(referencia!=null){
			criteria.add(Restrictions.like("referencia", "%"+referencia+"%"));
			logger.info("Busco por referencia");
			algo=true;
			
		}if(nombre!=null){
			criteria.add(Restrictions.like("nombre", "%"+nombre+"%"));
			logger.info("Busco por nombre");
			algo=true;
		}
		if(idTipoRequisito!=null){
			Criteria crit2 = criteria.createCriteria("idTipoRequisito");
			crit2.add(Restrictions.eq("idTipoRequisito",idTipoRequisito));
			
			logger.info("Busco por idTipoRequisito");
			algo=true;
		}
		if(detallerequisito!=null){
			
			criteriaDet=criteria.createCriteria("detallerequisito");
			criteriaDet.add(Restrictions.like("Detalle","%"+detallerequisito+"%"));
			logger.info("Busco por Detalle");
			algo=true;
		}
		if(requisito_relacionado!=null){
			logger.info("Busco por requisito_relacionado");
			if(RelacionrequisitoJpaController==null){
				RelacionrequisitoJpaController=(org.osiris.persistence.controllers.impl.RelacionrequisitoJpaController) ctx.getBean("RelacionrequisitoJpaController");
			}
			List<Relacionrequisito> reqs = RelacionrequisitoJpaController.findDependencias(requisito_relacionado);
			logger.info("Encontrados "+reqs.size()+" dependiencias");
			List <Long>values=new ArrayList<Long>();
			for(int z=0;z<reqs.size();z++){
				logger.info("Depende de "+reqs.get(z).getRelacionrequisitoPK().getRequisitoorigen());
				if(reqs.get(z).getRelacionrequisitoPK().getRequisitoorigen()!=requisito_relacionado.longValue()){
					values.add(reqs.get(z).getRelacionrequisitoPK().getRequisitoorigen());
				}
			}
			if(dependencia){
				if(values.size()>0){
					criteria.add(Restrictions.in("idRequisito",values));
					algo=true;
				}else {
					return new ArrayList <Requisito>();
				}
				
			}else {
				
					values.add(requisito_relacionado);
					criteria.add(Restrictions.not(Restrictions.in("idRequisito",values)));
					algo=true;
				
			}
			
			
		}
		if(origen!=null){
			if(criteriaDet==null){
				criteriaDet=criteria.createCriteria("detallerequisito");
			}
			criteriaDet.add(Restrictions.like("origen","%"+origen+"%"));
			logger.info("Busco por origen");
			algo=true;
		}
		if(idComplejidadRequisito!=null){
			logger.info("Busco por idComplejidadRequisito");
			Criteria crit2 = criteria.createCriteria("idComplejidadRequisito");			
			crit2.add(Restrictions.eq("idComplejidadRequisito",idComplejidadRequisito));
			algo=true;
		}
		if(idEstadoRequisito!=null){
			logger.info("Busco por idEstadoRequisito");
			Criteria crit2 = criteria.createCriteria("idEstadoRequisito");
			crit2.add(Restrictions.eq("idEstadoRequisito",idEstadoRequisito));
			algo=true;
			
		}
		if(PuntosFuncion!=null){
			criteria.add(Restrictions.eq("PuntosFuncion",PuntosFuncion));
			algo=true;
			
		}
		if(idRequisito!=null){
			logger.info("Busco por idRequisito");
			criteria.add(Restrictions.eq("idRequisito",idRequisito));
			algo=true;
			
		}
		if(idSubcategoria!=null){
			logger.info("Busco por idSubcategoria");
			Criteria crit2 = criteria.createCriteria("idSubcategoria");
			crit2.add(Restrictions.eq("idSubcategoria",idSubcategoria));
			algo=true;
		}
		if(responsable!=null){
			logger.info("Busco por responsable");
			Criteria crit2 = criteria.createCriteria("responsable");
			crit2.add(Restrictions.eq("idUsuario",responsable));
			algo=true;
			
		}
		
		if(proyecto!=null){	
			logger.info("Filtro por proyecto");
			List<Requisitosdeproyecto> sub =criteriaRequisitosdeproyecto.createCriteria("proyecto").add(Restrictions.eq("idProyecto",proyecto)).list();
			List<Long> values=new ArrayList<Long>();
			logger.info("HAY "+sub.size()+" requisitos para este proyecto");
			for(int x=0;x<sub.size();x++){
				values.add(sub.get(x).getRequisitosdeproyectoPK().getIdRequisito());
			}
			if(values.size()>0){
				if(dependencia){
					logger.info("Encuentro requisitos no relacionados con el proyecto");
					criteria.add(Restrictions.not(Restrictions.in("idRequisito",values)));
					algo=true;
				}else {
					logger.info("Encuentro requisitos relacionados con el proyecto");
					criteria.add(Restrictions.in("idRequisito",values));
					algo=true;
				}
			}
				
			
			
		}
		logger.info("Criteria:"+criteria.toString());
		List <Requisito> Requisitos =new ArrayList<Requisito>();
		if(algo){
			Requisitos = criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY).list();
		}else if(proyecto==null){	
			logger.info("Obtengo TODOS los requisitos");
			Requisitos =this.findRequisitoEntities();
		} 
		
		
        session.getTransaction().commit();
        logger.info("Devolviendo:"+Requisitos.size()+" encontrados");
        return Requisitos;
    	
        
        
        
    }
    public void create(Requisito requisito) {
        if (requisito.getRequisitosdeproyectoList() == null) {
            requisito.setRequisitosdeproyectoList(new ArrayList<Requisitosdeproyecto>());
        }
        if (requisito.getModificaciondeecList() == null) {
            requisito.setModificaciondeecList(new ArrayList<Modificaciondeec>());
        }
        if (requisito.getModificaciondeecCollection1() == null) {
            requisito.setModificaciondeecCollection1(new ArrayList<Modificaciondeec>());
        }
        if (requisito.getImpactocambioList() == null) {
            requisito.setImpactocambioList(new ArrayList<Impactocambio>());
        }
        if (requisito.getRecursosderequisitoList() == null) {
            requisito.setRecursosderequisitoList(new ArrayList<Recursosderequisito>());
        }
        if (requisito.getRiesgoList() == null) {
            requisito.setRiesgoList(new ArrayList<Riesgo>());
        }
        if (requisito.getRelacionrequisitoList() == null) {
            requisito.setRelacionrequisitoList(new ArrayList<Relacionrequisito>());
        }
        if (requisito.getRelacionrequisitoCollection1() == null) {
            requisito.setRelacionrequisitoCollection1(new ArrayList<Relacionrequisito>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Usuario autor = requisito.getAutor();
            if (autor != null) {
                autor = em.getReference(autor.getClass(), autor.getIdUsuario());
                requisito.setAutor(autor);
            }
            Tiporequisito idTipoRequisito = requisito.getIdTipoRequisito();
            if (idTipoRequisito != null) {
                idTipoRequisito = em.getReference(idTipoRequisito.getClass(), idTipoRequisito.getIdTipoRequisito());
                requisito.setIdTipoRequisito(idTipoRequisito);
            }
            Subcategoria idSubcategoria = requisito.getIdSubcategoria();
            if (idSubcategoria != null) {
                idSubcategoria = em.getReference(idSubcategoria.getClass(), idSubcategoria.getIdSubcategoria());
                requisito.setIdSubcategoria(idSubcategoria);
            }
            Estadorequisito idEstadoRequisito = requisito.getIdEstadoRequisito();
            if (idEstadoRequisito != null) {
                idEstadoRequisito = em.getReference(idEstadoRequisito.getClass(), idEstadoRequisito.getIdEstadoRequisito());
                requisito.setIdEstadoRequisito(idEstadoRequisito);
            }
            Usuario responsable = requisito.getResponsable();
            if (responsable != null) {
                responsable = em.getReference(responsable.getClass(), responsable.getIdUsuario());
                requisito.setResponsable(responsable);
            }
            Complejidadrequisito idComplejidadRequisito = requisito.getIdComplejidadRequisito();
            if (idComplejidadRequisito != null) {
                idComplejidadRequisito = em.getReference(idComplejidadRequisito.getClass(), idComplejidadRequisito.getIdComplejidadRequisito());
                requisito.setIdComplejidadRequisito(idComplejidadRequisito);
            }
            Detallerequisito detallerequisito = requisito.getDetallerequisito();
            if (detallerequisito != null) {
                detallerequisito = em.getReference(detallerequisito.getClass(), detallerequisito.getIdRequisito());
                requisito.setDetallerequisito(detallerequisito);
            }
            List<Requisitosdeproyecto> attachedRequisitosdeproyectoList = new ArrayList<Requisitosdeproyecto>();
            for (Requisitosdeproyecto requisitosdeproyectoListRequisitosdeproyectoToAttach : requisito.getRequisitosdeproyectoList()) {
                requisitosdeproyectoListRequisitosdeproyectoToAttach = em.getReference(requisitosdeproyectoListRequisitosdeproyectoToAttach.getClass(), requisitosdeproyectoListRequisitosdeproyectoToAttach.getRequisitosdeproyectoPK());
                attachedRequisitosdeproyectoList.add(requisitosdeproyectoListRequisitosdeproyectoToAttach);
            }
            requisito.setRequisitosdeproyectoList(attachedRequisitosdeproyectoList);
            List<Modificaciondeec> attachedModificaciondeecList = new ArrayList<Modificaciondeec>();
            for (Modificaciondeec modificaciondeecListModificaciondeecToAttach : requisito.getModificaciondeecList()) {
                modificaciondeecListModificaciondeecToAttach = em.getReference(modificaciondeecListModificaciondeecToAttach.getClass(), modificaciondeecListModificaciondeecToAttach.getIdModificacionDeRequisito());
                attachedModificaciondeecList.add(modificaciondeecListModificaciondeecToAttach);
            }
            requisito.setModificaciondeecList(attachedModificaciondeecList);
            List<Modificaciondeec> attachedModificaciondeecCollection1 = new ArrayList<Modificaciondeec>();
            for (Modificaciondeec modificaciondeecCollection1ModificaciondeecToAttach : requisito.getModificaciondeecCollection1()) {
                modificaciondeecCollection1ModificaciondeecToAttach = em.getReference(modificaciondeecCollection1ModificaciondeecToAttach.getClass(), modificaciondeecCollection1ModificaciondeecToAttach.getIdModificacionDeRequisito());
                attachedModificaciondeecCollection1.add(modificaciondeecCollection1ModificaciondeecToAttach);
            }
            requisito.setModificaciondeecCollection1(attachedModificaciondeecCollection1);
            List<Impactocambio> attachedImpactocambioList = new ArrayList<Impactocambio>();
            for (Impactocambio impactocambioListImpactocambioToAttach : requisito.getImpactocambioList()) {
                impactocambioListImpactocambioToAttach = em.getReference(impactocambioListImpactocambioToAttach.getClass(), impactocambioListImpactocambioToAttach.getIdPeticion());
                attachedImpactocambioList.add(impactocambioListImpactocambioToAttach);
            }
            requisito.setImpactocambioList(attachedImpactocambioList);
            List<Recursosderequisito> attachedRecursosderequisitoList = new ArrayList<Recursosderequisito>();
            for (Recursosderequisito recursosderequisitoListRecursosderequisitoToAttach : requisito.getRecursosderequisitoList()) {
                recursosderequisitoListRecursosderequisitoToAttach = em.getReference(recursosderequisitoListRecursosderequisitoToAttach.getClass(), recursosderequisitoListRecursosderequisitoToAttach.getRecursosderequisitoPK());
                attachedRecursosderequisitoList.add(recursosderequisitoListRecursosderequisitoToAttach);
            }
            requisito.setRecursosderequisitoList(attachedRecursosderequisitoList);
            List<Riesgo> attachedRiesgoList = new ArrayList<Riesgo>();
            for (Riesgo riesgoListRiesgoToAttach : requisito.getRiesgoList()) {
                riesgoListRiesgoToAttach = em.getReference(riesgoListRiesgoToAttach.getClass(), riesgoListRiesgoToAttach.getIdRiesgo());
                attachedRiesgoList.add(riesgoListRiesgoToAttach);
            }
            requisito.setRiesgoList(attachedRiesgoList);
            List<Relacionrequisito> attachedRelacionrequisitoList = new ArrayList<Relacionrequisito>();
            for (Relacionrequisito relacionrequisitoListRelacionrequisitoToAttach : requisito.getRelacionrequisitoList()) {
                relacionrequisitoListRelacionrequisitoToAttach = em.getReference(relacionrequisitoListRelacionrequisitoToAttach.getClass(), relacionrequisitoListRelacionrequisitoToAttach.getRelacionrequisitoPK());
                attachedRelacionrequisitoList.add(relacionrequisitoListRelacionrequisitoToAttach);
            }
            requisito.setRelacionrequisitoList(attachedRelacionrequisitoList);
            List<Relacionrequisito> attachedRelacionrequisitoCollection1 = new ArrayList<Relacionrequisito>();
            for (Relacionrequisito relacionrequisitoCollection1RelacionrequisitoToAttach : requisito.getRelacionrequisitoCollection1()) {
                relacionrequisitoCollection1RelacionrequisitoToAttach = em.getReference(relacionrequisitoCollection1RelacionrequisitoToAttach.getClass(), relacionrequisitoCollection1RelacionrequisitoToAttach.getRelacionrequisitoPK());
                attachedRelacionrequisitoCollection1.add(relacionrequisitoCollection1RelacionrequisitoToAttach);
            }
            requisito.setRelacionrequisitoCollection1(attachedRelacionrequisitoCollection1);
            em.persist(requisito);
            if (autor != null) {
                autor.getRequisitoList().add(requisito);
                autor = em.merge(autor);
            }
            if (idTipoRequisito != null) {
                idTipoRequisito.getRequisitoList().add(requisito);
                idTipoRequisito = em.merge(idTipoRequisito);
            }
            if (idSubcategoria != null) {
                idSubcategoria.getRequisitoList().add(requisito);
                idSubcategoria = em.merge(idSubcategoria);
            }
            if (idEstadoRequisito != null) {
                idEstadoRequisito.getRequisitoList().add(requisito);
                idEstadoRequisito = em.merge(idEstadoRequisito);
            }
            if (responsable != null) {
                responsable.getRequisitoList().add(requisito);
                responsable = em.merge(responsable);
            }
            if (idComplejidadRequisito != null) {
                idComplejidadRequisito.getRequisitoList().add(requisito);
                idComplejidadRequisito = em.merge(idComplejidadRequisito);
            }
            if (detallerequisito != null) {
                Requisito oldRequisitoOfDetallerequisito = detallerequisito.getRequisito();
                if (oldRequisitoOfDetallerequisito != null) {
                    oldRequisitoOfDetallerequisito.setDetallerequisito(null);
                    oldRequisitoOfDetallerequisito = em.merge(oldRequisitoOfDetallerequisito);
                }
                detallerequisito.setRequisito(requisito);
                detallerequisito = em.merge(detallerequisito);
            }
            for (Requisitosdeproyecto requisitosdeproyectoListRequisitosdeproyecto : requisito.getRequisitosdeproyectoList()) {
                Requisito oldRequisitoOfRequisitosdeproyectoListRequisitosdeproyecto = requisitosdeproyectoListRequisitosdeproyecto.getRequisito();
                requisitosdeproyectoListRequisitosdeproyecto.setRequisito(requisito);
                requisitosdeproyectoListRequisitosdeproyecto = em.merge(requisitosdeproyectoListRequisitosdeproyecto);
                if (oldRequisitoOfRequisitosdeproyectoListRequisitosdeproyecto != null) {
                    oldRequisitoOfRequisitosdeproyectoListRequisitosdeproyecto.getRequisitosdeproyectoList().remove(requisitosdeproyectoListRequisitosdeproyecto);
                    oldRequisitoOfRequisitosdeproyectoListRequisitosdeproyecto = em.merge(oldRequisitoOfRequisitosdeproyectoListRequisitosdeproyecto);
                }
            }
            for (Modificaciondeec modificaciondeecListModificaciondeec : requisito.getModificaciondeecList()) {
                Requisito oldIdRequisitodestinoOfModificaciondeecListModificaciondeec = modificaciondeecListModificaciondeec.getIdRequisitodestino();
                modificaciondeecListModificaciondeec.setIdRequisitodestino(requisito);
                modificaciondeecListModificaciondeec = em.merge(modificaciondeecListModificaciondeec);
                if (oldIdRequisitodestinoOfModificaciondeecListModificaciondeec != null) {
                    oldIdRequisitodestinoOfModificaciondeecListModificaciondeec.getModificaciondeecList().remove(modificaciondeecListModificaciondeec);
                    oldIdRequisitodestinoOfModificaciondeecListModificaciondeec = em.merge(oldIdRequisitodestinoOfModificaciondeecListModificaciondeec);
                }
            }
            for (Modificaciondeec modificaciondeecCollection1Modificaciondeec : requisito.getModificaciondeecCollection1()) {
                Requisito oldIdRequisitoorigenOfModificaciondeecCollection1Modificaciondeec = modificaciondeecCollection1Modificaciondeec.getIdRequisitoorigen();
                modificaciondeecCollection1Modificaciondeec.setIdRequisitoorigen(requisito);
                modificaciondeecCollection1Modificaciondeec = em.merge(modificaciondeecCollection1Modificaciondeec);
                if (oldIdRequisitoorigenOfModificaciondeecCollection1Modificaciondeec != null) {
                    oldIdRequisitoorigenOfModificaciondeecCollection1Modificaciondeec.getModificaciondeecCollection1().remove(modificaciondeecCollection1Modificaciondeec);
                    oldIdRequisitoorigenOfModificaciondeecCollection1Modificaciondeec = em.merge(oldIdRequisitoorigenOfModificaciondeecCollection1Modificaciondeec);
                }
            }
            for (Impactocambio impactocambioListImpactocambio : requisito.getImpactocambioList()) {
                Requisito oldIdRequisitoOfImpactocambioListImpactocambio = impactocambioListImpactocambio.getIdRequisito();
                impactocambioListImpactocambio.setIdRequisito(requisito);
                impactocambioListImpactocambio = em.merge(impactocambioListImpactocambio);
                if (oldIdRequisitoOfImpactocambioListImpactocambio != null) {
                    oldIdRequisitoOfImpactocambioListImpactocambio.getImpactocambioList().remove(impactocambioListImpactocambio);
                    oldIdRequisitoOfImpactocambioListImpactocambio = em.merge(oldIdRequisitoOfImpactocambioListImpactocambio);
                }
            }
            for (Recursosderequisito recursosderequisitoListRecursosderequisito : requisito.getRecursosderequisitoList()) {
                Requisito oldRequisitoOfRecursosderequisitoListRecursosderequisito = recursosderequisitoListRecursosderequisito.getRequisito();
                recursosderequisitoListRecursosderequisito.setRequisito(requisito);
                recursosderequisitoListRecursosderequisito = em.merge(recursosderequisitoListRecursosderequisito);
                if (oldRequisitoOfRecursosderequisitoListRecursosderequisito != null) {
                    oldRequisitoOfRecursosderequisitoListRecursosderequisito.getRecursosderequisitoList().remove(recursosderequisitoListRecursosderequisito);
                    oldRequisitoOfRecursosderequisitoListRecursosderequisito = em.merge(oldRequisitoOfRecursosderequisitoListRecursosderequisito);
                }
            }
            for (Riesgo riesgoListRiesgo : requisito.getRiesgoList()) {
                Requisito oldIdRequisitoOfRiesgoListRiesgo = riesgoListRiesgo.getIdRequisito();
                riesgoListRiesgo.setIdRequisito(requisito);
                riesgoListRiesgo = em.merge(riesgoListRiesgo);
                if (oldIdRequisitoOfRiesgoListRiesgo != null) {
                    oldIdRequisitoOfRiesgoListRiesgo.getRiesgoList().remove(riesgoListRiesgo);
                    oldIdRequisitoOfRiesgoListRiesgo = em.merge(oldIdRequisitoOfRiesgoListRiesgo);
                }
            }
            for (Relacionrequisito relacionrequisitoListRelacionrequisito : requisito.getRelacionrequisitoList()) {
                Requisito oldRequisitoOfRelacionrequisitoListRelacionrequisito = relacionrequisitoListRelacionrequisito.getRequisito();
                relacionrequisitoListRelacionrequisito.setRequisito(requisito);
                relacionrequisitoListRelacionrequisito = em.merge(relacionrequisitoListRelacionrequisito);
                if (oldRequisitoOfRelacionrequisitoListRelacionrequisito != null) {
                    oldRequisitoOfRelacionrequisitoListRelacionrequisito.getRelacionrequisitoList().remove(relacionrequisitoListRelacionrequisito);
                    oldRequisitoOfRelacionrequisitoListRelacionrequisito = em.merge(oldRequisitoOfRelacionrequisitoListRelacionrequisito);
                }
            }
            for (Relacionrequisito relacionrequisitoCollection1Relacionrequisito : requisito.getRelacionrequisitoCollection1()) {
                Requisito oldRequisito1OfRelacionrequisitoCollection1Relacionrequisito = relacionrequisitoCollection1Relacionrequisito.getRequisito1();
                relacionrequisitoCollection1Relacionrequisito.setRequisito1(requisito);
                relacionrequisitoCollection1Relacionrequisito = em.merge(relacionrequisitoCollection1Relacionrequisito);
                if (oldRequisito1OfRelacionrequisitoCollection1Relacionrequisito != null) {
                    oldRequisito1OfRelacionrequisitoCollection1Relacionrequisito.getRelacionrequisitoCollection1().remove(relacionrequisitoCollection1Relacionrequisito);
                    oldRequisito1OfRelacionrequisitoCollection1Relacionrequisito = em.merge(oldRequisito1OfRelacionrequisitoCollection1Relacionrequisito);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Requisito requisito) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Requisito persistentRequisito = em.find(Requisito.class, requisito.getIdRequisito());
            Usuario autorOld = persistentRequisito.getAutor();
            Usuario autorNew = requisito.getAutor();
            Tiporequisito idTipoRequisitoOld = persistentRequisito.getIdTipoRequisito();
            Tiporequisito idTipoRequisitoNew = requisito.getIdTipoRequisito();
            Subcategoria idSubcategoriaOld = persistentRequisito.getIdSubcategoria();
            Subcategoria idSubcategoriaNew = requisito.getIdSubcategoria();
            Estadorequisito idEstadoRequisitoOld = persistentRequisito.getIdEstadoRequisito();
            Estadorequisito idEstadoRequisitoNew = requisito.getIdEstadoRequisito();
            Usuario responsableOld = persistentRequisito.getResponsable();
            Usuario responsableNew = requisito.getResponsable();
            Complejidadrequisito idComplejidadRequisitoOld = persistentRequisito.getIdComplejidadRequisito();
            Complejidadrequisito idComplejidadRequisitoNew = requisito.getIdComplejidadRequisito();
            Detallerequisito detallerequisitoOld = persistentRequisito.getDetallerequisito();
            Detallerequisito detallerequisitoNew = requisito.getDetallerequisito();
            List<Requisitosdeproyecto> requisitosdeproyectoListOld = persistentRequisito.getRequisitosdeproyectoList();
            List<Requisitosdeproyecto> requisitosdeproyectoListNew = requisito.getRequisitosdeproyectoList();
            List<Modificaciondeec> modificaciondeecListOld = persistentRequisito.getModificaciondeecList();
            List<Modificaciondeec> modificaciondeecListNew = requisito.getModificaciondeecList();
            List<Modificaciondeec> modificaciondeecCollection1Old = persistentRequisito.getModificaciondeecCollection1();
            List<Modificaciondeec> modificaciondeecCollection1New = requisito.getModificaciondeecCollection1();
            List<Impactocambio> impactocambioListOld = persistentRequisito.getImpactocambioList();
            List<Impactocambio> impactocambioListNew = requisito.getImpactocambioList();
            List<Recursosderequisito> recursosderequisitoListOld = persistentRequisito.getRecursosderequisitoList();
            List<Recursosderequisito> recursosderequisitoListNew = requisito.getRecursosderequisitoList();
            List<Riesgo> riesgoListOld = persistentRequisito.getRiesgoList();
            List<Riesgo> riesgoListNew = requisito.getRiesgoList();
            List<Relacionrequisito> relacionrequisitoListOld = persistentRequisito.getRelacionrequisitoList();
            List<Relacionrequisito> relacionrequisitoListNew = requisito.getRelacionrequisitoList();
            List<Relacionrequisito> relacionrequisitoCollection1Old = persistentRequisito.getRelacionrequisitoCollection1();
            List<Relacionrequisito> relacionrequisitoCollection1New = requisito.getRelacionrequisitoCollection1();
            List<String> illegalOrphanMessages = null;
            if (detallerequisitoOld != null && !detallerequisitoOld.equals(detallerequisitoNew)) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("You must retain Detallerequisito " + detallerequisitoOld + " since its requisito field is not nullable.");
            }
            for (Requisitosdeproyecto requisitosdeproyectoListOldRequisitosdeproyecto : requisitosdeproyectoListOld) {
                if (!requisitosdeproyectoListNew.contains(requisitosdeproyectoListOldRequisitosdeproyecto)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Requisitosdeproyecto " + requisitosdeproyectoListOldRequisitosdeproyecto + " since its requisito field is not nullable.");
                }
            }
            for (Modificaciondeec modificaciondeecListOldModificaciondeec : modificaciondeecListOld) {
                if (!modificaciondeecListNew.contains(modificaciondeecListOldModificaciondeec)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Modificaciondeec " + modificaciondeecListOldModificaciondeec + " since its idRequisitodestino field is not nullable.");
                }
            }
            for (Modificaciondeec modificaciondeecCollection1OldModificaciondeec : modificaciondeecCollection1Old) {
                if (!modificaciondeecCollection1New.contains(modificaciondeecCollection1OldModificaciondeec)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Modificaciondeec " + modificaciondeecCollection1OldModificaciondeec + " since its idRequisitoorigen field is not nullable.");
                }
            }
            for (Impactocambio impactocambioListOldImpactocambio : impactocambioListOld) {
                if (!impactocambioListNew.contains(impactocambioListOldImpactocambio)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Impactocambio " + impactocambioListOldImpactocambio + " since its idRequisito field is not nullable.");
                }
            }
            for (Recursosderequisito recursosderequisitoListOldRecursosderequisito : recursosderequisitoListOld) {
                if (!recursosderequisitoListNew.contains(recursosderequisitoListOldRecursosderequisito)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Recursosderequisito " + recursosderequisitoListOldRecursosderequisito + " since its requisito field is not nullable.");
                }
            }
            for (Riesgo riesgoListOldRiesgo : riesgoListOld) {
                if (!riesgoListNew.contains(riesgoListOldRiesgo)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Riesgo " + riesgoListOldRiesgo + " since its idRequisito field is not nullable.");
                }
            }
            for (Relacionrequisito relacionrequisitoListOldRelacionrequisito : relacionrequisitoListOld) {
                if (!relacionrequisitoListNew.contains(relacionrequisitoListOldRelacionrequisito)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Relacionrequisito " + relacionrequisitoListOldRelacionrequisito + " since its requisito field is not nullable.");
                }
            }
            for (Relacionrequisito relacionrequisitoCollection1OldRelacionrequisito : relacionrequisitoCollection1Old) {
                if (!relacionrequisitoCollection1New.contains(relacionrequisitoCollection1OldRelacionrequisito)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Relacionrequisito " + relacionrequisitoCollection1OldRelacionrequisito + " since its requisito1 field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (autorNew != null) {
                autorNew = em.getReference(autorNew.getClass(), autorNew.getIdUsuario());
                requisito.setAutor(autorNew);
            }
            if (idTipoRequisitoNew != null) {
                idTipoRequisitoNew = em.getReference(idTipoRequisitoNew.getClass(), idTipoRequisitoNew.getIdTipoRequisito());
                requisito.setIdTipoRequisito(idTipoRequisitoNew);
            }
            if (idSubcategoriaNew != null) {
                idSubcategoriaNew = em.getReference(idSubcategoriaNew.getClass(), idSubcategoriaNew.getIdSubcategoria());
                requisito.setIdSubcategoria(idSubcategoriaNew);
            }
            if (idEstadoRequisitoNew != null) {
                idEstadoRequisitoNew = em.getReference(idEstadoRequisitoNew.getClass(), idEstadoRequisitoNew.getIdEstadoRequisito());
                requisito.setIdEstadoRequisito(idEstadoRequisitoNew);
            }
            if (responsableNew != null) {
                responsableNew = em.getReference(responsableNew.getClass(), responsableNew.getIdUsuario());
                requisito.setResponsable(responsableNew);
            }
            if (idComplejidadRequisitoNew != null) {
                idComplejidadRequisitoNew = em.getReference(idComplejidadRequisitoNew.getClass(), idComplejidadRequisitoNew.getIdComplejidadRequisito());
                requisito.setIdComplejidadRequisito(idComplejidadRequisitoNew);
            }
            if (detallerequisitoNew != null) {
                detallerequisitoNew = em.getReference(detallerequisitoNew.getClass(), detallerequisitoNew.getIdRequisito());
                requisito.setDetallerequisito(detallerequisitoNew);
            }
            List<Requisitosdeproyecto> attachedRequisitosdeproyectoListNew = new ArrayList<Requisitosdeproyecto>();
            for (Requisitosdeproyecto requisitosdeproyectoListNewRequisitosdeproyectoToAttach : requisitosdeproyectoListNew) {
                requisitosdeproyectoListNewRequisitosdeproyectoToAttach = em.getReference(requisitosdeproyectoListNewRequisitosdeproyectoToAttach.getClass(), requisitosdeproyectoListNewRequisitosdeproyectoToAttach.getRequisitosdeproyectoPK());
                attachedRequisitosdeproyectoListNew.add(requisitosdeproyectoListNewRequisitosdeproyectoToAttach);
            }
            requisitosdeproyectoListNew = attachedRequisitosdeproyectoListNew;
            requisito.setRequisitosdeproyectoList(requisitosdeproyectoListNew);
            List<Modificaciondeec> attachedModificaciondeecListNew = new ArrayList<Modificaciondeec>();
            for (Modificaciondeec modificaciondeecListNewModificaciondeecToAttach : modificaciondeecListNew) {
                modificaciondeecListNewModificaciondeecToAttach = em.getReference(modificaciondeecListNewModificaciondeecToAttach.getClass(), modificaciondeecListNewModificaciondeecToAttach.getIdModificacionDeRequisito());
                attachedModificaciondeecListNew.add(modificaciondeecListNewModificaciondeecToAttach);
            }
            modificaciondeecListNew = attachedModificaciondeecListNew;
            requisito.setModificaciondeecList(modificaciondeecListNew);
            List<Modificaciondeec> attachedModificaciondeecCollection1New = new ArrayList<Modificaciondeec>();
            for (Modificaciondeec modificaciondeecCollection1NewModificaciondeecToAttach : modificaciondeecCollection1New) {
                modificaciondeecCollection1NewModificaciondeecToAttach = em.getReference(modificaciondeecCollection1NewModificaciondeecToAttach.getClass(), modificaciondeecCollection1NewModificaciondeecToAttach.getIdModificacionDeRequisito());
                attachedModificaciondeecCollection1New.add(modificaciondeecCollection1NewModificaciondeecToAttach);
            }
            modificaciondeecCollection1New = attachedModificaciondeecCollection1New;
            requisito.setModificaciondeecCollection1(modificaciondeecCollection1New);
            List<Impactocambio> attachedImpactocambioListNew = new ArrayList<Impactocambio>();
            for (Impactocambio impactocambioListNewImpactocambioToAttach : impactocambioListNew) {
                impactocambioListNewImpactocambioToAttach = em.getReference(impactocambioListNewImpactocambioToAttach.getClass(), impactocambioListNewImpactocambioToAttach.getIdPeticion());
                attachedImpactocambioListNew.add(impactocambioListNewImpactocambioToAttach);
            }
            impactocambioListNew = attachedImpactocambioListNew;
            requisito.setImpactocambioList(impactocambioListNew);
            List<Recursosderequisito> attachedRecursosderequisitoListNew = new ArrayList<Recursosderequisito>();
            for (Recursosderequisito recursosderequisitoListNewRecursosderequisitoToAttach : recursosderequisitoListNew) {
                recursosderequisitoListNewRecursosderequisitoToAttach = em.getReference(recursosderequisitoListNewRecursosderequisitoToAttach.getClass(), recursosderequisitoListNewRecursosderequisitoToAttach.getRecursosderequisitoPK());
                attachedRecursosderequisitoListNew.add(recursosderequisitoListNewRecursosderequisitoToAttach);
            }
            recursosderequisitoListNew = attachedRecursosderequisitoListNew;
            requisito.setRecursosderequisitoList(recursosderequisitoListNew);
            List<Riesgo> attachedRiesgoListNew = new ArrayList<Riesgo>();
            for (Riesgo riesgoListNewRiesgoToAttach : riesgoListNew) {
                riesgoListNewRiesgoToAttach = em.getReference(riesgoListNewRiesgoToAttach.getClass(), riesgoListNewRiesgoToAttach.getIdRiesgo());
                attachedRiesgoListNew.add(riesgoListNewRiesgoToAttach);
            }
            riesgoListNew = attachedRiesgoListNew;
            requisito.setRiesgoList(riesgoListNew);
            List<Relacionrequisito> attachedRelacionrequisitoListNew = new ArrayList<Relacionrequisito>();
            for (Relacionrequisito relacionrequisitoListNewRelacionrequisitoToAttach : relacionrequisitoListNew) {
                relacionrequisitoListNewRelacionrequisitoToAttach = em.getReference(relacionrequisitoListNewRelacionrequisitoToAttach.getClass(), relacionrequisitoListNewRelacionrequisitoToAttach.getRelacionrequisitoPK());
                attachedRelacionrequisitoListNew.add(relacionrequisitoListNewRelacionrequisitoToAttach);
            }
            relacionrequisitoListNew = attachedRelacionrequisitoListNew;
            requisito.setRelacionrequisitoList(relacionrequisitoListNew);
            List<Relacionrequisito> attachedRelacionrequisitoCollection1New = new ArrayList<Relacionrequisito>();
            for (Relacionrequisito relacionrequisitoCollection1NewRelacionrequisitoToAttach : relacionrequisitoCollection1New) {
                relacionrequisitoCollection1NewRelacionrequisitoToAttach = em.getReference(relacionrequisitoCollection1NewRelacionrequisitoToAttach.getClass(), relacionrequisitoCollection1NewRelacionrequisitoToAttach.getRelacionrequisitoPK());
                attachedRelacionrequisitoCollection1New.add(relacionrequisitoCollection1NewRelacionrequisitoToAttach);
            }
            relacionrequisitoCollection1New = attachedRelacionrequisitoCollection1New;
            requisito.setRelacionrequisitoCollection1(relacionrequisitoCollection1New);
            requisito = em.merge(requisito);
            if (autorOld != null && !autorOld.equals(autorNew)) {
                autorOld.getRequisitoList().remove(requisito);
                autorOld = em.merge(autorOld);
            }
            if (autorNew != null && !autorNew.equals(autorOld)) {
                autorNew.getRequisitoList().add(requisito);
                autorNew = em.merge(autorNew);
            }
            if (idTipoRequisitoOld != null && !idTipoRequisitoOld.equals(idTipoRequisitoNew)) {
                idTipoRequisitoOld.getRequisitoList().remove(requisito);
                idTipoRequisitoOld = em.merge(idTipoRequisitoOld);
            }
            if (idTipoRequisitoNew != null && !idTipoRequisitoNew.equals(idTipoRequisitoOld)) {
                idTipoRequisitoNew.getRequisitoList().add(requisito);
                idTipoRequisitoNew = em.merge(idTipoRequisitoNew);
            }
            if (idSubcategoriaOld != null && !idSubcategoriaOld.equals(idSubcategoriaNew)) {
                idSubcategoriaOld.getRequisitoList().remove(requisito);
                idSubcategoriaOld = em.merge(idSubcategoriaOld);
            }
            if (idSubcategoriaNew != null && !idSubcategoriaNew.equals(idSubcategoriaOld)) {
                idSubcategoriaNew.getRequisitoList().add(requisito);
                idSubcategoriaNew = em.merge(idSubcategoriaNew);
            }
            if (idEstadoRequisitoOld != null && !idEstadoRequisitoOld.equals(idEstadoRequisitoNew)) {
                idEstadoRequisitoOld.getRequisitoList().remove(requisito);
                idEstadoRequisitoOld = em.merge(idEstadoRequisitoOld);
            }
            if (idEstadoRequisitoNew != null && !idEstadoRequisitoNew.equals(idEstadoRequisitoOld)) {
                idEstadoRequisitoNew.getRequisitoList().add(requisito);
                idEstadoRequisitoNew = em.merge(idEstadoRequisitoNew);
            }
            if (responsableOld != null && !responsableOld.equals(responsableNew)) {
                responsableOld.getRequisitoList().remove(requisito);
                responsableOld = em.merge(responsableOld);
            }
            if (responsableNew != null && !responsableNew.equals(responsableOld)) {
                responsableNew.getRequisitoList().add(requisito);
                responsableNew = em.merge(responsableNew);
            }
            if (idComplejidadRequisitoOld != null && !idComplejidadRequisitoOld.equals(idComplejidadRequisitoNew)) {
                idComplejidadRequisitoOld.getRequisitoList().remove(requisito);
                idComplejidadRequisitoOld = em.merge(idComplejidadRequisitoOld);
            }
            if (idComplejidadRequisitoNew != null && !idComplejidadRequisitoNew.equals(idComplejidadRequisitoOld)) {
                idComplejidadRequisitoNew.getRequisitoList().add(requisito);
                idComplejidadRequisitoNew = em.merge(idComplejidadRequisitoNew);
            }
            if (detallerequisitoNew != null && !detallerequisitoNew.equals(detallerequisitoOld)) {
                Requisito oldRequisitoOfDetallerequisito = detallerequisitoNew.getRequisito();
                if (oldRequisitoOfDetallerequisito != null) {
                    oldRequisitoOfDetallerequisito.setDetallerequisito(null);
                    oldRequisitoOfDetallerequisito = em.merge(oldRequisitoOfDetallerequisito);
                }
                detallerequisitoNew.setRequisito(requisito);
                detallerequisitoNew = em.merge(detallerequisitoNew);
            }
            for (Requisitosdeproyecto requisitosdeproyectoListNewRequisitosdeproyecto : requisitosdeproyectoListNew) {
                if (!requisitosdeproyectoListOld.contains(requisitosdeproyectoListNewRequisitosdeproyecto)) {
                    Requisito oldRequisitoOfRequisitosdeproyectoListNewRequisitosdeproyecto = requisitosdeproyectoListNewRequisitosdeproyecto.getRequisito();
                    requisitosdeproyectoListNewRequisitosdeproyecto.setRequisito(requisito);
                    requisitosdeproyectoListNewRequisitosdeproyecto = em.merge(requisitosdeproyectoListNewRequisitosdeproyecto);
                    if (oldRequisitoOfRequisitosdeproyectoListNewRequisitosdeproyecto != null && !oldRequisitoOfRequisitosdeproyectoListNewRequisitosdeproyecto.equals(requisito)) {
                        oldRequisitoOfRequisitosdeproyectoListNewRequisitosdeproyecto.getRequisitosdeproyectoList().remove(requisitosdeproyectoListNewRequisitosdeproyecto);
                        oldRequisitoOfRequisitosdeproyectoListNewRequisitosdeproyecto = em.merge(oldRequisitoOfRequisitosdeproyectoListNewRequisitosdeproyecto);
                    }
                }
            }
            for (Modificaciondeec modificaciondeecListNewModificaciondeec : modificaciondeecListNew) {
                if (!modificaciondeecListOld.contains(modificaciondeecListNewModificaciondeec)) {
                    Requisito oldIdRequisitodestinoOfModificaciondeecListNewModificaciondeec = modificaciondeecListNewModificaciondeec.getIdRequisitodestino();
                    modificaciondeecListNewModificaciondeec.setIdRequisitodestino(requisito);
                    modificaciondeecListNewModificaciondeec = em.merge(modificaciondeecListNewModificaciondeec);
                    if (oldIdRequisitodestinoOfModificaciondeecListNewModificaciondeec != null && !oldIdRequisitodestinoOfModificaciondeecListNewModificaciondeec.equals(requisito)) {
                        oldIdRequisitodestinoOfModificaciondeecListNewModificaciondeec.getModificaciondeecList().remove(modificaciondeecListNewModificaciondeec);
                        oldIdRequisitodestinoOfModificaciondeecListNewModificaciondeec = em.merge(oldIdRequisitodestinoOfModificaciondeecListNewModificaciondeec);
                    }
                }
            }
            for (Modificaciondeec modificaciondeecCollection1NewModificaciondeec : modificaciondeecCollection1New) {
                if (!modificaciondeecCollection1Old.contains(modificaciondeecCollection1NewModificaciondeec)) {
                    Requisito oldIdRequisitoorigenOfModificaciondeecCollection1NewModificaciondeec = modificaciondeecCollection1NewModificaciondeec.getIdRequisitoorigen();
                    modificaciondeecCollection1NewModificaciondeec.setIdRequisitoorigen(requisito);
                    modificaciondeecCollection1NewModificaciondeec = em.merge(modificaciondeecCollection1NewModificaciondeec);
                    if (oldIdRequisitoorigenOfModificaciondeecCollection1NewModificaciondeec != null && !oldIdRequisitoorigenOfModificaciondeecCollection1NewModificaciondeec.equals(requisito)) {
                        oldIdRequisitoorigenOfModificaciondeecCollection1NewModificaciondeec.getModificaciondeecCollection1().remove(modificaciondeecCollection1NewModificaciondeec);
                        oldIdRequisitoorigenOfModificaciondeecCollection1NewModificaciondeec = em.merge(oldIdRequisitoorigenOfModificaciondeecCollection1NewModificaciondeec);
                    }
                }
            }
            for (Impactocambio impactocambioListNewImpactocambio : impactocambioListNew) {
                if (!impactocambioListOld.contains(impactocambioListNewImpactocambio)) {
                    Requisito oldIdRequisitoOfImpactocambioListNewImpactocambio = impactocambioListNewImpactocambio.getIdRequisito();
                    impactocambioListNewImpactocambio.setIdRequisito(requisito);
                    impactocambioListNewImpactocambio = em.merge(impactocambioListNewImpactocambio);
                    if (oldIdRequisitoOfImpactocambioListNewImpactocambio != null && !oldIdRequisitoOfImpactocambioListNewImpactocambio.equals(requisito)) {
                        oldIdRequisitoOfImpactocambioListNewImpactocambio.getImpactocambioList().remove(impactocambioListNewImpactocambio);
                        oldIdRequisitoOfImpactocambioListNewImpactocambio = em.merge(oldIdRequisitoOfImpactocambioListNewImpactocambio);
                    }
                }
            }
            for (Recursosderequisito recursosderequisitoListNewRecursosderequisito : recursosderequisitoListNew) {
                if (!recursosderequisitoListOld.contains(recursosderequisitoListNewRecursosderequisito)) {
                    Requisito oldRequisitoOfRecursosderequisitoListNewRecursosderequisito = recursosderequisitoListNewRecursosderequisito.getRequisito();
                    recursosderequisitoListNewRecursosderequisito.setRequisito(requisito);
                    recursosderequisitoListNewRecursosderequisito = em.merge(recursosderequisitoListNewRecursosderequisito);
                    if (oldRequisitoOfRecursosderequisitoListNewRecursosderequisito != null && !oldRequisitoOfRecursosderequisitoListNewRecursosderequisito.equals(requisito)) {
                        oldRequisitoOfRecursosderequisitoListNewRecursosderequisito.getRecursosderequisitoList().remove(recursosderequisitoListNewRecursosderequisito);
                        oldRequisitoOfRecursosderequisitoListNewRecursosderequisito = em.merge(oldRequisitoOfRecursosderequisitoListNewRecursosderequisito);
                    }
                }
            }
            for (Riesgo riesgoListNewRiesgo : riesgoListNew) {
                if (!riesgoListOld.contains(riesgoListNewRiesgo)) {
                    Requisito oldIdRequisitoOfRiesgoListNewRiesgo = riesgoListNewRiesgo.getIdRequisito();
                    riesgoListNewRiesgo.setIdRequisito(requisito);
                    riesgoListNewRiesgo = em.merge(riesgoListNewRiesgo);
                    if (oldIdRequisitoOfRiesgoListNewRiesgo != null && !oldIdRequisitoOfRiesgoListNewRiesgo.equals(requisito)) {
                        oldIdRequisitoOfRiesgoListNewRiesgo.getRiesgoList().remove(riesgoListNewRiesgo);
                        oldIdRequisitoOfRiesgoListNewRiesgo = em.merge(oldIdRequisitoOfRiesgoListNewRiesgo);
                    }
                }
            }
            for (Relacionrequisito relacionrequisitoListNewRelacionrequisito : relacionrequisitoListNew) {
                if (!relacionrequisitoListOld.contains(relacionrequisitoListNewRelacionrequisito)) {
                    Requisito oldRequisitoOfRelacionrequisitoListNewRelacionrequisito = relacionrequisitoListNewRelacionrequisito.getRequisito();
                    relacionrequisitoListNewRelacionrequisito.setRequisito(requisito);
                    relacionrequisitoListNewRelacionrequisito = em.merge(relacionrequisitoListNewRelacionrequisito);
                    if (oldRequisitoOfRelacionrequisitoListNewRelacionrequisito != null && !oldRequisitoOfRelacionrequisitoListNewRelacionrequisito.equals(requisito)) {
                        oldRequisitoOfRelacionrequisitoListNewRelacionrequisito.getRelacionrequisitoList().remove(relacionrequisitoListNewRelacionrequisito);
                        oldRequisitoOfRelacionrequisitoListNewRelacionrequisito = em.merge(oldRequisitoOfRelacionrequisitoListNewRelacionrequisito);
                    }
                }
            }
            for (Relacionrequisito relacionrequisitoCollection1NewRelacionrequisito : relacionrequisitoCollection1New) {
                if (!relacionrequisitoCollection1Old.contains(relacionrequisitoCollection1NewRelacionrequisito)) {
                    Requisito oldRequisito1OfRelacionrequisitoCollection1NewRelacionrequisito = relacionrequisitoCollection1NewRelacionrequisito.getRequisito1();
                    relacionrequisitoCollection1NewRelacionrequisito.setRequisito1(requisito);
                    relacionrequisitoCollection1NewRelacionrequisito = em.merge(relacionrequisitoCollection1NewRelacionrequisito);
                    if (oldRequisito1OfRelacionrequisitoCollection1NewRelacionrequisito != null && !oldRequisito1OfRelacionrequisitoCollection1NewRelacionrequisito.equals(requisito)) {
                        oldRequisito1OfRelacionrequisitoCollection1NewRelacionrequisito.getRelacionrequisitoCollection1().remove(relacionrequisitoCollection1NewRelacionrequisito);
                        oldRequisito1OfRelacionrequisitoCollection1NewRelacionrequisito = em.merge(oldRequisito1OfRelacionrequisitoCollection1NewRelacionrequisito);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Long id = requisito.getIdRequisito();
                if (findRequisito(id) == null) {
                    throw new NonexistentEntityException("The requisito with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Long id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Requisito requisito;
            try {
                requisito = em.getReference(Requisito.class, id);
                requisito.getIdRequisito();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The requisito with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Detallerequisito detallerequisitoOrphanCheck = requisito.getDetallerequisito();
            if (detallerequisitoOrphanCheck != null) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Detallerequisito " + detallerequisitoOrphanCheck + " in its detallerequisito field has a non-nullable requisito field.");
            }
            List<Requisitosdeproyecto> requisitosdeproyectoListOrphanCheck = requisito.getRequisitosdeproyectoList();
            for (Requisitosdeproyecto requisitosdeproyectoListOrphanCheckRequisitosdeproyecto : requisitosdeproyectoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Requisitosdeproyecto " + requisitosdeproyectoListOrphanCheckRequisitosdeproyecto + " in its requisitosdeproyectoList field has a non-nullable requisito field.");
            }
            List<Modificaciondeec> modificaciondeecListOrphanCheck = requisito.getModificaciondeecList();
            for (Modificaciondeec modificaciondeecListOrphanCheckModificaciondeec : modificaciondeecListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Modificaciondeec " + modificaciondeecListOrphanCheckModificaciondeec + " in its modificaciondeecList field has a non-nullable idRequisitodestino field.");
            }
            List<Modificaciondeec> modificaciondeecCollection1OrphanCheck = requisito.getModificaciondeecCollection1();
            for (Modificaciondeec modificaciondeecCollection1OrphanCheckModificaciondeec : modificaciondeecCollection1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Modificaciondeec " + modificaciondeecCollection1OrphanCheckModificaciondeec + " in its modificaciondeecCollection1 field has a non-nullable idRequisitoorigen field.");
            }
            List<Impactocambio> impactocambioListOrphanCheck = requisito.getImpactocambioList();
            for (Impactocambio impactocambioListOrphanCheckImpactocambio : impactocambioListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Impactocambio " + impactocambioListOrphanCheckImpactocambio + " in its impactocambioList field has a non-nullable idRequisito field.");
            }
            List<Recursosderequisito> recursosderequisitoListOrphanCheck = requisito.getRecursosderequisitoList();
            for (Recursosderequisito recursosderequisitoListOrphanCheckRecursosderequisito : recursosderequisitoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Recursosderequisito " + recursosderequisitoListOrphanCheckRecursosderequisito + " in its recursosderequisitoList field has a non-nullable requisito field.");
            }
            List<Riesgo> riesgoListOrphanCheck = requisito.getRiesgoList();
            for (Riesgo riesgoListOrphanCheckRiesgo : riesgoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Riesgo " + riesgoListOrphanCheckRiesgo + " in its riesgoList field has a non-nullable idRequisito field.");
            }
            List<Relacionrequisito> relacionrequisitoListOrphanCheck = requisito.getRelacionrequisitoList();
            for (Relacionrequisito relacionrequisitoListOrphanCheckRelacionrequisito : relacionrequisitoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Relacionrequisito " + relacionrequisitoListOrphanCheckRelacionrequisito + " in its relacionrequisitoList field has a non-nullable requisito field.");
            }
            List<Relacionrequisito> relacionrequisitoCollection1OrphanCheck = requisito.getRelacionrequisitoCollection1();
            for (Relacionrequisito relacionrequisitoCollection1OrphanCheckRelacionrequisito : relacionrequisitoCollection1OrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Requisito (" + requisito + ") cannot be destroyed since the Relacionrequisito " + relacionrequisitoCollection1OrphanCheckRelacionrequisito + " in its relacionrequisitoCollection1 field has a non-nullable requisito1 field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Usuario autor = requisito.getAutor();
            if (autor != null) {
                autor.getRequisitoList().remove(requisito);
                autor = em.merge(autor);
            }
            Tiporequisito idTipoRequisito = requisito.getIdTipoRequisito();
            if (idTipoRequisito != null) {
                idTipoRequisito.getRequisitoList().remove(requisito);
                idTipoRequisito = em.merge(idTipoRequisito);
            }
            Subcategoria idSubcategoria = requisito.getIdSubcategoria();
            if (idSubcategoria != null) {
                idSubcategoria.getRequisitoList().remove(requisito);
                idSubcategoria = em.merge(idSubcategoria);
            }
            Estadorequisito idEstadoRequisito = requisito.getIdEstadoRequisito();
            if (idEstadoRequisito != null) {
                idEstadoRequisito.getRequisitoList().remove(requisito);
                idEstadoRequisito = em.merge(idEstadoRequisito);
            }
            Usuario responsable = requisito.getResponsable();
            if (responsable != null) {
                responsable.getRequisitoList().remove(requisito);
                responsable = em.merge(responsable);
            }
            Complejidadrequisito idComplejidadRequisito = requisito.getIdComplejidadRequisito();
            if (idComplejidadRequisito != null) {
                idComplejidadRequisito.getRequisitoList().remove(requisito);
                idComplejidadRequisito = em.merge(idComplejidadRequisito);
            }
            em.remove(requisito);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Requisito> findRequisitoEntities() {
        return findRequisitoEntities(true, -1, -1);
    }

    public List<Requisito> findRequisitoEntities(int maxResults, int firstResult) {
        return findRequisitoEntities(false, maxResults, firstResult);
    }

    private List<Requisito> findRequisitoEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Requisito as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Requisito findRequisito(Long id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Requisito.class, id);
        } finally {
            em.close();
        }
    }

    public int getRequisitoCount() {
        EntityManager em = getEntityManager();
        try {
            return ((Long) em.createQuery("select count(o) from Requisito as o").getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }


}
